package com.fbinggun.fbinggunutil.API;

import java.util.*;

/**
 * 常用几率计算、权重计算方法
 */
public class RandomUtil {
    //获取范围随机数

    /**
     * 获取范围内随机数
     * @param max 最大值
     * @param min 最小值
     * @return
     */
    public static double getDoubleRandom(double max, double min) {
        if(max==min){
            return min;
        }
             java.util.Random r = new java.util.Random();
            int maxs = (int) (max*100);
            int mins= (int) (min*100);
            double n2 = mins + r.nextInt(maxs - mins);
            return n2/100;
    }

    /**
     * 获取范围内随机数
     * @param max 最大值
     * @param min 最小值
     * @return
     */
    //去范围随机数
    public static int getIntRandom(int max, int min) {
        if(max==min){
            return min;
        }
        java.util.Random r=new java.util.Random();
        int n3 = r.nextInt(max+1-min)+min;
        return  n3;
    }
    public static void main(String[] args) {
        for(int x=0;x<=20;x++) {
            System.out.println(getDoubleRandom(3, 0));
        }
    }


    /**
     * 权重计算
     * @param map 权重合集
     * @return 返回Map <T,几率>
     * @param <T>
     */
    public static <T> Map<T,Double> weightCalculate(Map<T,Integer> map){
        int count =getWeightTotalCount(map);
        Map<T,Double> r =new HashMap<>();
        List<Map.Entry<T, Integer>> list = new ArrayList<>(map.entrySet());
        for (Map.Entry<T, Integer> mapping : list) {
            double v=((double)mapping.getValue())/count;
            r.put(mapping.getKey(),v);
        }
        return r;
        }
        //获得权重总数
        public static <T> int getWeightTotalCount(Map<T,Integer> map){
            int count =0;
            for(int v:map.values()) {
                count = count + v;
            }
            return count;
        }
    //获得权重几率

    /**
     * 获得合集中的 几率
     * @param map 权重合集
     * @param t 要获取的成员值
     * @return 返回成员值的几率
     * @param <T>
     */
    public static <T> double weightProbability(Map<T,Integer> map,T t){
        int count =getWeightTotalCount(map);
        if(map.get(t)==null){
            return 0d;
        }
        double jl =0.00000001;
        jl=jl+(double)map.get(t)/count;
        return jl;
    }

    /**
     * 根据权重 随机抽取一个成员
     * @param map 权重合集
     * @return 成员
     * @param <T>
     */
    //使用权重抽取一个项目 <T,权重>
    public static <T> T getRandomWeightItem(Map<T,Integer> map){
        int count =getWeightTotalCount(map);
        while (true) {
            for (T t : map.keySet()) {
                int weight = map.get(t);
                int random = getIntRandom(count, 1);
                if (weight >= random) {
                    return t;
                }
            }
        }
    }

    /**
     * 根据几率 随机抽取一个成员
     * @param map 几率合集
     * @return 随机成员
     * @param <T>
     */
    //使用几率抽取一个项目 <T,几率>
    public static <T> T getRandomItem(Map<T,Double> map){
        while (true) {
            for (T t : map.keySet()) {
                double weight = map.get(t);
                if(is(weight)){
                    return t;
                }
            }
        }
    }

    /**
     * 获得一个0~0.999... 范围内的一个小数
     * @return
     */
    //随机数
    public static Double sj() {
        java.util.Random r = new java.util.Random();
        Double n2 = r.nextDouble();
        return n2;
    }

    /**
     * 判断几率是否成功
     * @param Jl 几率
     * @return 成功返回true
     */
    public static boolean is(double Jl){
        if(sj()<=Jl){
            return true;
        }
        return false;
    }



}
